#include "../games/globale.h" // Fonction et Headers globaux
#include "../games/cls_scenario.h" // Classe de gestion du scenario

/* ----------------------------------------------------
			Constructeur
  ----------------------------------------------------- */
cls_Scenario::cls_Scenario()
{
    debugTrace("Constructeur cls_Scenario");
    this->t_valPerso.empty();
    this->t_valEvenement.empty();
    this->t_valObjets.empty();
}

/* ----------------------------------------------------
			Destructeur
  ----------------------------------------------------- */
cls_Scenario::~cls_Scenario()
{
    debugTrace("Destructeur cls_Scenario");
    this->t_valPerso.empty();
    this->t_valEvenement.empty();
    this->t_valObjets.empty();
}


/* ----------------------------------------------------
			Initialisation
  ----------------------------------------------------- */
int cls_Scenario::Init()
{

    ifstream fileConfiguration;
    ofstream saveConfigFile;
    string s_FileLine;
    string s_KeyWord;
    string s_KeyWordAction;
    vector<string> VecStr;


    fileConfiguration.open("data/scenario/01/result.dat");
    if (fileConfiguration) // ce test échoue si le fichier n'est pas ouvert
    {

        while(getline(fileConfiguration, s_FileLine))
        {

            if(s_FileLine.substr(0, 2) != "//")
            {
                // PARAMETRE DE LA MAP
                s_KeyWord="[MAP:";
                if((int)s_FileLine.find(s_KeyWord, 0) != -1)
                {
                    // découpage de la chaine
                    VecStr.clear();
                    strSplit(s_FileLine.substr(s_KeyWord.length(), s_FileLine.length() - s_KeyWord.length() - 1), VecStr, ",");

                    // On vérifie qu'il y a bien 7 valeurs !!!
                    if (VecStr.size() == 7)
                    {
                        this->valMap.st_FileName = VecStr[0];
                        strToLong(VecStr[1], this->valMap.n_MapWidth);
                        strToLong(VecStr[2], this->valMap.n_MapHeight);
                        strToLong(VecStr[3], this->valMap.n_MapVelocity);
                        strToLong(VecStr[4], this->valMap.n_MapDelay);
                        strToLong(VecStr[5], this->valMap.n_DefaultX);
                        strToLong(VecStr[6], this->valMap.n_DefaultY);
                        debugTrace("Fichier Scénario [MAP:...] (OK)");
                    }
                    else
                    {
                        debugTrace("Fichier Scénario [MAP:...] (---- ERREUR ----)");
                        return NOTOK;
                    }
                }



                // PARAMETRE DES PERSONNAGES
                s_KeyWord="[PERSO:";
                if((int)s_FileLine.find(s_KeyWord, 0) != -1)
                {

                    // découpage de la chaine
                    VecStr.clear();
                    strSplit(s_FileLine.substr(s_KeyWord.length(), s_FileLine.length() - s_KeyWord.length() - 1), VecStr, ",");

                    // On vérifie qu'il y a bien 13 valeurs !!!
                    if (VecStr.size() == 13)
                    {
                        // Création d'un tableau avec STL
                        // http://cpp.developpez.com/faq/cpp/?page=STL
                        StrucPerso objTempo;
                        strToLong(VecStr[0], objTempo.st_PersoID);
                        objTempo.st_SpriteNameMouvement = VecStr[1];
                        strToLong(VecStr[2], objTempo.n_SpriteMouvement);
                        objTempo.st_SpriteNameImmobile = VecStr[3];
                        strToLong(VecStr[4], objTempo.n_SpriteNumberImmobile);
                        strToLong(VecStr[5], objTempo.n_SpriteWidth);
                        strToLong(VecStr[6], objTempo.n_SpriteHeight);
                        strToLong(VecStr[7], objTempo.n_SpriteLeftBorder);
                        strToLong(VecStr[8], objTempo.n_SpriteRightBorder);
                        strToLong(VecStr[9], objTempo.n_SpriteVelocity);
                        strToLong(VecStr[10], objTempo.n_SpriteDelay);
                        strToLong(VecStr[11], objTempo.n_DefaultX);
                        strToLong(VecStr[12], objTempo.n_DefaultY);
                        this->t_valPerso.push_back(objTempo);

                        debugTrace("Fichier Scénario [PERSO:...] (OK)");
                    }
                    else
                    {
                        debugTrace("Fichier Scénario [PERSO:...] (---- ERREUR ----)");
                        return NOTOK;
                    }
                }

                // PARAMETRE PAR DEFAUT DES VALEURS DES EVENEMENTS
                s_KeyWord="[INIT_EVT:";
                if((int)s_FileLine.find(s_KeyWord, 0) != -1)
                {

                    // découpage de la chaine
                    VecStr.clear();
                    strSplit(s_FileLine.substr(s_KeyWord.length(), s_FileLine.length() - s_KeyWord.length() - 1), VecStr, "=");

                    // On vérifie qu'il y a bien 2 valeurs !!!
                    if (VecStr.size() == 2)
                    {
                        StrucEvenement objTempo;
                        objTempo.st_Nom = VecStr[0];
                        if (VecStr[1] == "TRUE")
                        {
                            objTempo.isActive = true;
                        }
                        else
                        {
                            objTempo.isActive = false;
                        }
                        this->t_valEvenement.push_back(objTempo);
                        debugTrace("Fichier Scénario [INIT_EVT:...] (OK)");
                    }
                    else
                    {
                        debugTrace("Fichier Scénario [INIT_EVT:...] (---- ERREUR ----)");
                        return NOTOK;
                    }
                }

                // PARAMETRE PAR DEFAUT DES VALEURS DES EVENEMENTS
                s_KeyWord="[OBJET:";
                if((int)s_FileLine.find(s_KeyWord, 0) != -1)
                {
                    // découpage de la chaine
                    VecStr.clear();
                    strSplit(s_FileLine.substr(s_KeyWord.length(), s_FileLine.length() - s_KeyWord.length() - 1), VecStr, ",");

                    // On vérifie qu'il y a bien 6 valeurs !!!
                    if (VecStr.size() == 6)
                    {
                        StrucObjets objTempo;
                        objTempo.st_Nom = VecStr[0];
                        objTempo.st_FileName = VecStr[1];
                        strToLong(VecStr[2], objTempo.n_ObjetWidth);
                        strToLong(VecStr[3], objTempo.n_ObjetHeight);
                        strToLong(VecStr[4], objTempo.n_DefaultX);
                        strToLong(VecStr[5], objTempo.n_DefaultY);

                        // Il faut récupérer toutes les conditions pour cet objet !!
                        // Une fois l'objet récupéré, il faut lire jusqu'a la balise [/OBJET]
                        // pour récupéré les actions de l'objet.
                        s_KeyWord="[/OBJET]";
                        while(getline(fileConfiguration, s_FileLine) && (int)s_FileLine.find(s_KeyWord, 0) == -1)
                        {
                            if(s_FileLine.substr(0, 2) != "//")
                            {
                                s_KeyWordAction="[ACTION:REGARDER]";
                                if((int)s_FileLine.find(s_KeyWordAction, 0) != -1)
                                {
                                    s_KeyWordAction="[/ACTION]";
                                    while(getline(fileConfiguration, s_FileLine) && (int)s_FileLine.find(s_KeyWordAction, 0) == -1)
                                    {
                                        if(s_FileLine.substr(0, 2) != "//")
                                        {
                                            // découpage de la chaine
                                            VecStr.clear();
                                            strSplit(s_FileLine, VecStr, "|");

                                            // On vérifie qu'il y a bien 4 valeurs !!!
                                            if (VecStr.size() == 4)
                                            {
                                                StrucCondition objTempoCondition;
                                                objTempoCondition.st_Condition = VecStr[0];
                                                objTempoCondition.st_Description = VecStr[1];
                                                objTempoCondition.st_Reponse = VecStr[2];
                                                objTempoCondition.st_Resultat = VecStr[3];
                                                objTempo.actionLook.push_back(objTempoCondition);
                                                debugTrace("Fichier Scénario [ACTION:REGARDER] (OK)");
                                            }
                                            else
                                            {
                                                debugTrace("Fichier Scénario [ACTION:REGARDER] (---- ERREUR ----)");
                                                return NOTOK;
                                            }
                                        }
                                    }
                                }


                                s_KeyWordAction="[ACTION:OUVRIR]";
                                if((int)s_FileLine.find(s_KeyWordAction, 0) != -1)
                                {
                                    s_KeyWordAction="[/ACTION]";
                                    while(getline(fileConfiguration, s_FileLine) && (int)s_FileLine.find(s_KeyWordAction, 0) == -1)
                                    {
                                        if(s_FileLine.substr(0, 2) != "//")
                                        {
                                            // découpage de la chaine
                                            VecStr.clear();
                                            strSplit(s_FileLine, VecStr, "|");

                                            // On vérifie qu'il y a bien 4 valeurs !!!
                                            if (VecStr.size() == 4)
                                            {
                                                StrucCondition objTempoCondition;
                                                objTempoCondition.st_Condition = VecStr[0];
                                                objTempoCondition.st_Description = VecStr[1];
                                                objTempoCondition.st_Reponse = VecStr[2];
                                                objTempoCondition.st_Resultat = VecStr[3];
                                                objTempo.actionOpen.push_back(objTempoCondition);
                                                debugTrace("Fichier Scénario [ACTION:OUVRIR] (OK)");
                                            }
                                            else
                                            {
                                                debugTrace("Fichier Scénario [ACTION:OUVRIR] (---- ERREUR ----)");
                                                return NOTOK;
                                            }
                                        }
                                    }
                                }

                                s_KeyWordAction="[ACTION:PRENDRE]";
                                if((int)s_FileLine.find(s_KeyWordAction, 0) != -1)
                                {
                                    s_KeyWordAction="[/ACTION]";
                                    while(getline(fileConfiguration, s_FileLine) && (int)s_FileLine.find(s_KeyWordAction, 0) == -1)
                                    {
                                        if(s_FileLine.substr(0, 2) != "//")
                                        {
                                            // découpage de la chaine
                                            VecStr.clear();
                                            strSplit(s_FileLine, VecStr, "|");

                                            // On vérifie qu'il y a bien 4 valeurs !!!
                                            if (VecStr.size() == 4)
                                            {
                                                StrucCondition objTempoCondition;
                                                objTempoCondition.st_Condition = VecStr[0];
                                                objTempoCondition.st_Description = VecStr[1];
                                                objTempoCondition.st_Reponse = VecStr[2];
                                                objTempoCondition.st_Resultat = VecStr[3];
                                                objTempo.actionTake.push_back(objTempoCondition);
                                                debugTrace("Fichier Scénario [ACTION:PRENDRE] (OK)");
                                            }
                                            else
                                            {
                                                debugTrace("Fichier Scénario [ACTION:PRENDRE] (---- ERREUR ----)");
                                                return NOTOK;
                                            }
                                        }
                                    }
                                }


                                s_KeyWordAction="[ACTION:FERMER]";
                                if((int)s_FileLine.find(s_KeyWordAction, 0) != -1)
                                {
                                    s_KeyWordAction="[/ACTION]";
                                    while(getline(fileConfiguration, s_FileLine) && (int)s_FileLine.find(s_KeyWordAction, 0) == -1)
                                    {
                                        if(s_FileLine.substr(0, 2) != "//")
                                        {
                                            // découpage de la chaine
                                            VecStr.clear();
                                            strSplit(s_FileLine, VecStr, "|");

                                            // On vérifie qu'il y a bien 4 valeurs !!!
                                            if (VecStr.size() == 4)
                                            {
                                                StrucCondition objTempoCondition;
                                                objTempoCondition.st_Condition = VecStr[0];
                                                objTempoCondition.st_Description = VecStr[1];
                                                objTempoCondition.st_Reponse = VecStr[2];
                                                objTempoCondition.st_Resultat = VecStr[3];
                                                objTempo.actionClose.push_back(objTempoCondition);
                                                debugTrace("Fichier Scénario [ACTION:FERMER] (OK)");
                                            }
                                            else
                                            {
                                                debugTrace("Fichier Scénario [ACTION:FERMER] (---- ERREUR ----)");
                                                return NOTOK;
                                            }
                                        }
                                    }
                                }


                                s_KeyWordAction="[ACTION:PARLER]";
                                if((int)s_FileLine.find(s_KeyWordAction, 0) != -1)
                                {
                                    s_KeyWordAction="[/ACTION]";
                                    while(getline(fileConfiguration, s_FileLine) && (int)s_FileLine.find(s_KeyWordAction, 0) == -1)
                                    {
                                        if(s_FileLine.substr(0, 2) != "//")
                                        {
                                            // découpage de la chaine
                                            VecStr.clear();
                                            strSplit(s_FileLine, VecStr, "|");

                                            // On vérifie qu'il y a bien 4 valeurs !!!
                                            if (VecStr.size() == 4)
                                            {
                                                StrucCondition objTempoCondition;
                                                objTempoCondition.st_Condition = VecStr[0];
                                                objTempoCondition.st_Description = VecStr[1];
                                                objTempoCondition.st_Reponse = VecStr[2];
                                                objTempoCondition.st_Resultat = VecStr[3];
                                                objTempo.actionTalk.push_back(objTempoCondition);
                                                debugTrace("Fichier Scénario [ACTION:PARLER] (OK)");
                                            }
                                            else
                                            {
                                                debugTrace("Fichier Scénario [ACTION:PARLER] (---- ERREUR ----)");
                                                return NOTOK;
                                            }
                                        }
                                    }
                                }


                                s_KeyWordAction="[ACTION:UTILISER]";
                                if((int)s_FileLine.find(s_KeyWordAction, 0) != -1)
                                {
                                    s_KeyWordAction="[/ACTION]";
                                    while(getline(fileConfiguration, s_FileLine) && (int)s_FileLine.find(s_KeyWordAction, 0) == -1)
                                    {
                                        if(s_FileLine.substr(0, 2) != "//")
                                        {
                                            // découpage de la chaine
                                            VecStr.clear();
                                            strSplit(s_FileLine, VecStr, "|");

                                            // On vérifie qu'il y a bien 4 valeurs !!!
                                            if (VecStr.size() == 4)
                                            {
                                                StrucCondition objTempoCondition;
                                                objTempoCondition.st_Condition = VecStr[0];
                                                objTempoCondition.st_Description = VecStr[1];
                                                objTempoCondition.st_Reponse = VecStr[2];
                                                objTempoCondition.st_Resultat = VecStr[3];
                                                objTempo.actionUse.push_back(objTempoCondition);
                                                debugTrace("Fichier Scénario [ACTION:UTILISER] (OK)");
                                            }
                                            else
                                            {
                                                debugTrace("Fichier Scénario [ACTION:UTILISER] (---- ERREUR ----)");
                                                return NOTOK;
                                            }
                                        }
                                    }
                                }


                            }
                        }

                        this->t_valObjets.push_back(objTempo);
                        debugTrace("Fichier Scénario [OBJET:...] (OK)");
                    }
                    else
                    {
                        debugTrace("Fichier Scénario [OBJET:...] (---- ERREUR ----)");
                        return NOTOK;
                    }

                }

                // PARAMETRE DE ...

            }
        }
    }

    fileConfiguration.close();

    return RETOK;
}


/* ----------------------------------------------------
			Accesseur
  ----------------------------------------------------- */
StrucMap* cls_Scenario::getParaMap()
{
    return &this->valMap;
}
/*
vector<StrucObjets>* cls_Scenario::getParaObjets()
{
    return &this->t_valObjets;
}
*/
